home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / proc / procTypes.h < prev    next >
C/C++ Source or Header  |  1992-12-18  |  18KB  |  549 lines
  1. /*
  2.  * procTypes.h --
  3.  *
  4.  *    External declarations of data structures
  5.  *    for managing processes.
  6.  *
  7.  * Copyright 1986, 1988 Regents of the University of California
  8.  * Permission to use, copy, modify, and distribute this
  9.  * software and its documentation for any purpose and without
  10.  * fee is hereby granted, provided that the above copyright
  11.  * notice appear in all copies.  The University of California
  12.  * makes no representations about the suitability of this
  13.  * software for any purpose.  It is provided "as is" without
  14.  * express or implied warranty.
  15.  *
  16.  *
  17.  * rcsid $Header: /cdrom/src/kernel/Cvsroot/kernel/proc/procTypes.h,v 1.10 92/06/01 14:42:48 kupfer Exp $ SPRITE (Berkeley)
  18.  */
  19.  
  20. #ifndef _PROCTYPES
  21. #define _PROCTYPES
  22.  
  23. #ifdef KERNEL
  24. #include <user/proc.h>
  25. #include <user/sync.h>
  26. #include <syncLock.h>
  27. #include <list.h>
  28. #include <timer.h>
  29. #include <sigTypes.h>
  30. #include <machTypes.h>
  31. #include <sysSysCallParam.h>
  32. #else
  33. #include <proc.h>
  34. #include <sync.h>
  35. #include <kernel/syncLock.h>
  36. #include <list.h>
  37. #include <kernel/timer.h>
  38. #include <kernel/sigTypes.h>
  39. #include <kernel/machTypes.h>
  40. #endif /* */
  41.  
  42. /*
  43.  * Constants for Proc_Exec().  
  44.  *
  45.  * PROC_MAX_EXEC_ARG_LENGTH    The maximum length of all arguments that are
  46.  *                passed to exec.  Also used to bound any
  47.  *                individual argument.
  48.  * PROC_MAX_EXEC_ARGS        The maximum number of arguments that can be
  49.  *                passed to an exec'd process.  By making it
  50.  *                the same, each argument could conceivably be
  51.  *                a single byte.
  52.  */
  53.  
  54. #define    PROC_MAX_EXEC_ARG_LENGTH    20480
  55. #define    PROC_MAX_EXEC_ARGS        20480
  56.  
  57. /*
  58.  * Masks to extract the proc table index and the generation number from
  59.  * a process id.  Process IDs need to be unique across reuses of the same
  60.  * procTable slot, and they need to be unique from host to host.
  61.  */
  62.  
  63. /*
  64.  * PROC_INDEX_MASK is defined in user/proc.h.
  65.  * #define    PROC_INDEX_MASK        0x000000FF
  66.  */
  67. #define    PROC_ID_NUM_MASK    0x0000FF00
  68. #define PROC_ID_NUM_SHIFT    8
  69. #define    PROC_GEN_NUM_MASK    0x000F0000
  70. #define PROC_GEN_NUM_SHIFT    16
  71.  
  72.  
  73. /*
  74.  * Number of locks that can be pushed on the lock stack for a process. The
  75.  * stack is used in the sync module to determine the locking structure of the
  76.  * system.
  77.  */
  78. #define PROC_LOCKSTACK_SIZE 10
  79.  
  80.  
  81. /* DATA STRUCTURES */
  82.  
  83. /*
  84.  * Structure passed to the function called by Proc_CallFunc.
  85.  */
  86. typedef struct {
  87.     unsigned int    interval;    /* Set by func to cause it to be 
  88.                      * rescheduled. */
  89.     ClientData        clientData;    /* Data given to Proc_CallFunc*(). */
  90.     ClientData        token;        /* Unique token to identify this call.*/
  91. } Proc_CallInfo;
  92.  
  93. /*
  94.  * Structure to describe an environment.
  95.  */
  96.  
  97. typedef struct {
  98.     int            refCount;    /* Number of processes using this 
  99.                      * environment. */
  100.     int            size;        /* Number of elements in environment. */
  101.     struct ProcEnvironVar *varArray;    /* The environment itself. */
  102. } Proc_EnvironInfo;
  103.  
  104. /*
  105.  * >>> Process state flags have been moved to user/proc.h <<<
  106.  */
  107.  
  108. /*
  109.  *  Proc_PCBLinks is used to link the PCB entry into various doubly-linked
  110.  *  lists. For example, processes waiting on an event are linked togther.
  111.  */
  112.  
  113. typedef struct {
  114.     List_Links links;            /* Linked list for the hash chain. */
  115.     struct Proc_ControlBlock *procPtr;    /* Back pointer to this structure. */
  116. } Proc_PCBLink;
  117.  
  118.  
  119. /*
  120.  * Proc_Time is used to represent time such that it can be understood
  121.  * by users through Proc_GetPCBInfo in a machine independent format and
  122.  * by the kernel in a machine dependent ticks format.  Thus all users of
  123.  * Proc_Time in the kernel should always use the ticks field and user
  124.  * programs that call Proc_GetPCBInfo should use the time field.
  125.  */
  126. typedef union {
  127.     Timer_Ticks    ticks;    /* The kernel's notion of time. */
  128.     Time    time;    /* The user's notion of time. */
  129. } Proc_Time;
  130.  
  131. typedef struct {
  132.     int        type;        /* type of lock */
  133.     Address    lockPtr;    /* Ptr to lock */
  134. } Proc_LockStackElement;
  135.  
  136. /*
  137.  *  The Proc_ControlBlock structure:
  138.  *   It contains information to manage the process such as virtual 
  139.  *   memory usage, cpu usage, scheduling info, process state, 
  140.  *   which processor the process is executing on, etc.
  141.  */
  142.  
  143. typedef struct Proc_ControlBlock {
  144.     List_Links    links;        /* Used to link processes together. */
  145.  
  146.     int        processor;    /* Processor number the process is running on
  147.                  * or wants to run on if the processor is
  148.                  * available.  */
  149.  
  150.     Proc_State    state;        /* Describes a process's current running state.
  151.                  * >>> See Proc_State definitions in
  152.                  * >>> user/proc.h. */ 
  153.  
  154.     int        genFlags;    /* Flags to describe a processes overall state.
  155.                  * >>> See definitions in user/proc.h. */ 
  156.     int        syncFlags;    /* Flags used by the sync module. */
  157.     int        schedFlags;    /* Flags used by the sched module. */
  158.     int        exitFlags;    /* Flags used by the exit-detach-
  159.                   * wait monitor. */
  160.  
  161.     List_Links        childListHdr;    /* Header for list of children. */
  162.     List_Links        *childList;    /* Pointer to header of list. */
  163.     Proc_PCBLink    siblingElement;    /* Element in list of sibling 
  164.                      * processes. */
  165.     Proc_PCBLink    familyElement;    /* Element in a list of family
  166.                        members. */
  167.  
  168.     /*
  169.      *-----------------------------------------------------------------
  170.      *
  171.      *   Various Process Identifiers.
  172.      *    
  173.      *    Note that the user and effectiveUser ID are kept here because
  174.      *    they are used for permission checking in various places.  There
  175.      *    is also a list of group IDs which is kept in the filesystem state.
  176.      *
  177.      *-----------------------------------------------------------------
  178.      */
  179.  
  180.     Proc_PID    processID;        /* Actual process ID of this
  181.                      * process (for migrated processes
  182.                      * this is different than the PID
  183.                      * that the user sees). */
  184.     Proc_PID    parentID;        /* The process ID of the parent 
  185.                      * of this process. */
  186.     int        familyID;        /* The id of the process family that 
  187.                      * this process belongs to. */
  188.     int        userID;            /* The user id is used to check access
  189.                      * rights to files and check ability
  190.                      * to signal other processes. */
  191.     int        effectiveUserID;    /* The effective user id is used
  192.                      * for setuid access. */
  193.  
  194.     /*
  195.      *-----------------------------------------------------------------
  196.      *
  197.      *    Synchronization fields.
  198.      *
  199.      * Synchronization state includes an event the process is waiting on.
  200.      * PCB's are linked into a hash chain keyed on this event.
  201.      *
  202.      *-----------------------------------------------------------------
  203.      */
  204.  
  205.     int         event;         /* Event # the process is waiting for. */
  206.     Proc_PCBLink eventHashChain; /* Hash chain this PCB is linked to */
  207.  
  208.     /*
  209.      * Monitor conditions for locking this PCB entry.
  210.      */
  211.  
  212.     Sync_Condition    waitCondition;
  213.     Sync_Condition    lockedCondition;
  214.  
  215.     /*
  216.      * Fields for remote waiting.  A token is kept to guard against the
  217.      * race between the wakeup message and the process's decision to sleep.
  218.      */
  219.  
  220.     int            waitToken;
  221.  
  222.     /*
  223.      *-----------------------------------------------------------------
  224.      *
  225.      *    Scheduling fields.
  226.      *
  227.      *-----------------------------------------------------------------
  228.      */
  229.  
  230.  
  231.     int      billingRate;    /* Modifies the scheduler's calculation of
  232.                  * the processes priority.  */
  233.     unsigned int recentUsage;    /* Amount of CPU time used recently */
  234.     unsigned int weightedUsage;    /* Smoothed avg. of CPU usage, weighted by
  235.                  * billing rate. */
  236.     unsigned int unweightedUsage; /* Smoothed avg. of CPU usage, not weighted by
  237.                    * billing rate. */
  238.  
  239.     /*
  240.      *-----------------------------------------------------------------
  241.      *
  242.      *    Accounting and Resource Usage fields.
  243.      *
  244.      *-----------------------------------------------------------------
  245.      */
  246.  
  247.     Proc_Time kernelCpuUsage;    /* How much time has been spent in kernel mode*/
  248.     Proc_Time userCpuUsage;    /* How much time has been spent in user mode. */
  249.  
  250.     Proc_Time childKernelCpuUsage;    /* Sum of time spent in kernel mode for 
  251.                       * all terminated children. */
  252.     Proc_Time childUserCpuUsage;    /* Sum of time spent in user mode for
  253.                       * all terminated children. */
  254.     int     numQuantumEnds;        /* number of times the process was 
  255.                       * context switched due to a quantum 
  256.                      * end. */
  257.     int        numWaitEvents;        /* number of times the process was
  258.                      * context switched due to its waiting 
  259.                      * for an event. */
  260.     unsigned int schedQuantumTicks;    /* Number of clock ticks until this 
  261.                      * process is due to be switched out. */
  262.  
  263.  
  264.     /*
  265.      *-----------------------------------------------------------------
  266.      *
  267.      *   Machine-Dependent fields.
  268.      *
  269.      *    General processor registers, stack information.
  270.      *
  271.      *-----------------------------------------------------------------
  272.      */ 
  273.     struct    Mach_State    *machStatePtr;
  274.  
  275.  
  276.     /*
  277.      *-----------------------------------------------------------------
  278.      *
  279.      *   Virtual Memory fields.
  280.      *
  281.      *-----------------------------------------------------------------
  282.      */
  283.     struct    Vm_ProcInfo    *vmPtr;
  284.  
  285.     /*
  286.      *-----------------------------------------------------------------
  287.      *
  288.      *   I/O and File System fields.
  289.      *
  290.      *-----------------------------------------------------------------
  291.      */
  292.  
  293.     struct Fs_ProcessState    *fsPtr;
  294.  
  295.     /*
  296.      *-----------------------------------------------------------------
  297.      *
  298.      *   Termination Reason, Status and Status Subcode Information.
  299.      *
  300.      *-----------------------------------------------------------------
  301.      */
  302.  
  303.     int    termReason;        /* Reason why process has died or
  304.                  * it has been detached. */
  305.                 /* >>> See definitions in procUser.h */
  306.     int    termStatus;        /* Exit/detach status or signal number
  307.                  * that caused the process to die. */
  308.                 /* >>> See definitions in procUser.h */
  309.     int    termCode;        /* The code for the signal. */
  310.                 /* >>> See definitions in procUser.h */
  311.  
  312.  
  313.     /*
  314.      *-----------------------------------------------------------------
  315.      *
  316.      *    Signals
  317.      *
  318.      *-----------------------------------------------------------------
  319.      */
  320.  
  321.     int        sigHoldMask;        /* Mask of signals to be held. */
  322.     int        sigPendingMask;        /* Mask of pending signals.  Some 
  323.                      * care is needed to keep the mask
  324.                      * consistent with genFlags. */
  325.                         /* Array of the different types
  326.                        of actions for signals. */
  327.     int        sigActions[SIG_NUM_SIGNALS];
  328.                         /* Array of signal hold masks for 
  329.                        signal handlers. */
  330.     int        sigMasks[SIG_NUM_SIGNALS];
  331.                     /* Array of signal handlers for 
  332.                        signals. */
  333.     int        sigCodes[SIG_NUM_SIGNALS];
  334.     int        sigFlags;        /* Flags to indicate the signal 
  335.                        state. */
  336.     int        oldSigHoldMask;        /* Mask of held signals when a
  337.                        Sig_Pause call starts. */
  338.     int        sigAddr;        /* Address of the fault. */
  339.  
  340.     /*
  341.      * Info for interval timers. The timer info is not put directly in
  342.      * this struct so additional timers can be added without extending
  343.      * the struct. This information is used to deliver the SIG_TIMER signal
  344.      * to the process.
  345.      */
  346.     struct ProcIntTimerInfo    *timerArray;
  347.  
  348.     /*
  349.      *---------------------------------------------------------------------
  350.      *
  351.      * Data for process migration.
  352.      *
  353.      *---------------------------------------------------------------------
  354.      */
  355.     int            peerHostID;    /* If on home node, ID of remote node.
  356.                      * If on remote node, ID of home node.
  357.                      * If not migrated, undefined. */
  358.     Proc_PID        peerProcessID;     /* If on remote note, process ID on
  359.                      * home node, and vice-versa. */
  360.     struct Proc_ControlBlock
  361.                  *rpcClientProcess;    /* procPtr for migrated process
  362.                      * performing system call, if
  363.                      * applicable. */
  364.  
  365.     /*
  366.      *---------------------------------------------------------------------
  367.      *
  368.      *  Miscellaneous items:
  369.      *
  370.      *---------------------------------------------------------------------
  371.      */
  372.  
  373.     /*
  374.      * Info that describes the process's environment variable table.
  375.      */
  376.     Proc_EnvironInfo    *environPtr;
  377.  
  378.     /*
  379.      * Arguments for the process, taken from Proc_Exec.
  380.      */
  381.     char    *argString;
  382.  
  383. #ifdef LOCKDEP
  384.     /*
  385.      * Stack of locks that process has grabbed.
  386.      */
  387.      Proc_LockStackElement    lockStack[PROC_LOCKSTACK_SIZE];
  388.      int            lockStackSize;
  389. #endif
  390.  
  391. #ifndef CLEAN_LOCK
  392.     /*
  393.      * Information on contention for PCB locks. PCB locks are implemented
  394.      * as a bit in the genflag field and don't use the standard locking
  395.      * stuff. The following field is used to keep lock information. 
  396.      * Its type is Sync_Semaphore, but it is not used as such.
  397.      */
  398.      Sync_Semaphore        lockInfo;
  399. #endif
  400.  
  401.     /*
  402.      * Used to speed up basic kernel-call processing.  These two fields
  403.      * must be next to each other in the table, and in the order below.
  404.      * If you change this, you'll have to change the assembler code that
  405.      * takes kernel-call traps.
  406.      */
  407.  
  408.     ReturnStatus (**kcallTable)();    /* Pointer to array of addresses,
  409.                      * which are procedures to handle
  410.                      * the various kernel calls.  Points
  411.                      * to a different place for migrated
  412.                      * processes than for processes running
  413.                      * at home. */
  414.     int specialHandling;        /* If non-zero, means the process
  415.                      * requires special (slower) handling
  416.                      * (deliver signal, switch contexts,
  417.                      * etc.) on return from the next kernel
  418.                      * call. */
  419.  
  420.     /*
  421.      *---------------------------------------------------------------------
  422.      *
  423.      *  User level profiling information
  424.      *
  425.      *---------------------------------------------------------------------
  426.      */
  427.  
  428.      short *Prof_Buffer;    /* Pointer to an array of profiling information
  429.                              * in the process's address space. */
  430.      int Prof_BufferSize;   /* The size of Prof_Buffer. */
  431.      int Prof_Offset;       /* Value subtracted from the program counter */
  432.      int Prof_Scale;        /* 16 bit fixed point fraction.  Scales the PC
  433.                              * to fit in the Prof_Buffer */
  434.      int Prof_PC;           /* Program counter recorded during the last
  435.                              * timer tick. */
  436.  
  437.     /*
  438.      * This needs to go with the other migration stuff but can't without
  439.      * a world recompile.
  440.      */
  441.     Address    remoteExecBuffer;     /* Buffer to store info for remote
  442.                       * exec prior to migration. */
  443.     Address    migCmdBuffer;         /* Buffer to store multi-part
  444.                       * migration command. */
  445.     int        migCmdBufSize;         /* Size of migCmdBuffer, for
  446.                       * sanity checks. */
  447.     int        migFlags;         /* Flags used for migration. (Needs
  448.                       * to be reorganized to include things
  449.                       * currently in genFlags but that will
  450.                       * also require a world recompile.) */
  451.     Proc_Time   preEvictionUsage;      /* CPU usage (user + kernel)
  452.                       * as of the start of
  453.                       * eviction. */
  454.  
  455.     /*
  456.      * UNIX compatibility.
  457.      */
  458.  
  459.     int         unixErrno;               /* Errno for unix system call. */
  460.     /* 
  461.      * As a random convention, we'll set unixProgress to -1 if the 
  462.      * program is not in unix compatibility mode; otherwise 
  463.      * unixProgres != -1.
  464.      */
  465.     int         unixProgress;            /* Progress indicator for restarting
  466.                                             unix system calls. */
  467.  
  468.     /* 
  469.      * Instrumentation.
  470.      */
  471.     Timer_Ticks syscallStartTime;     /* start time for the current 
  472.                      * system call */
  473.  
  474.     /*
  475.      *---------------------------------------------------------------------
  476.      *
  477.      *  Extra padding, so that we can add fields to this struct 
  478.      *  without changing its size.
  479.      *
  480.      *---------------------------------------------------------------------
  481.      */
  482.  
  483.     int        extraField[8];        /* Extra fields for later use. */
  484.  
  485. } Proc_ControlBlock;
  486.  
  487. /*
  488.  * Exit-detach-wait monitor flags:
  489.  *
  490.  *  PROC_DETACHED        - This process is detached from its parent.
  491.  *                  When this process exits, it won't go on the
  492.  *                  exiting processes list.
  493.  *  PROC_WAITED_ON        - This process is detached and the parent has 
  494.  *                  already done a Proc_Wait on it.
  495.  *  PROC_SUSPEND_STATUS        - The process went into the suspended state
  496.  *                  and it hasn't been waited on yet.
  497.  *  PROC_RESUME_STATUS        - The process was resumed and it hasn't been 
  498.  *                  waited on yet.
  499.  *  PROC_STATUSES        - The union of the two above statuses.
  500.  */
  501.  
  502. #define PROC_DETACHED        0x01
  503. #define PROC_WAITED_ON        0x02
  504. #define    PROC_SUSPEND_STATUS    0x04
  505. #define    PROC_RESUME_STATUS    0x08
  506. #define    PROC_STATUSES        (PROC_SUSPEND_STATUS | PROC_RESUME_STATUS)
  507.  
  508. /*
  509.  * Information for encapsulating process state.
  510.  */
  511.  
  512. /*
  513.  * Identifiers to match encapsulated states and modules.
  514.  * Make sure to update PROC_MIG_NUM_CALLBACKS if one is added!
  515.  */
  516. typedef enum {
  517.     PROC_MIG_ENCAP_PROC,
  518.     PROC_MIG_ENCAP_VM,
  519.     PROC_MIG_ENCAP_FS,
  520.     PROC_MIG_ENCAP_MACH,
  521.     PROC_MIG_ENCAP_PROF,
  522.     PROC_MIG_ENCAP_SIG,
  523.     PROC_MIG_ENCAP_EXEC
  524. } Proc_EncapToken;
  525.  
  526. #define PROC_MIG_NUM_CALLBACKS 7
  527.  
  528. /*
  529.  * Each module that participates has a token defined for it.
  530.  * It also provides routines to encapsulate and deencapsulate data,
  531.  * as well as optional routines that may be called prior to migration
  532.  * and subsequent to migration.  This structure is passed around to
  533.  * other modules performing encapsulation.
  534.  */
  535. typedef struct {
  536.     Proc_EncapToken    token;        /* info about encapsulated data */
  537.     int            size;        /* size of encapsulated data */
  538.     ClientData        data;        /* for use by encapsulator */
  539.     int            special;    /* indicates special action required */
  540.     ClientData        specialToken;    /* for use during special action */
  541.     int            processed;    /* indicates this module did possibly
  542.                        destructive encapsulation operation
  543.                        and should be called to clean up
  544.                        on failure */
  545.  
  546. } Proc_EncapInfo;
  547.  
  548. #endif /* _PROCTYPES */
  549.